const api = require("../../request/api")
const request = require("../../request/request")
const util = require("../../utils/util")
const App = getApp();

// 优惠券过期时间定时器
let timer = null

let combo_list = [{
    title: '银卡订单',
    price: 1226,
    originPrice: '1300',
    // goodId: 222,
    goodId: 244,
    buytip: '1226',
    discount: ' 98折',
    img: "https://jinding.gzzsu.com/wxacode/202407/202407171746267457.jpg"
},
{
    title: '金卡订单',
    price: 3000,
    originPrice: '3800',
    // goodId: 223,
    goodId: 244,
    buytip: '3000',
    discount: ' 95折',
    img: "https://jinding.gzzsu.com/wxacode/202407/202407171746267457.jpg"
},
{
    title: '钻石订单',
    price: 6000,
    originPrice: '6500',
    // goodId: 224,
    goodId: 244,
    buytip: '6000',
    discount: ' 92折',
    img: "https://jinding.gzzsu.com/wxacode/202407/202407171746267457.jpg"
}]

Page({

    /**
     * 页面的初始数据
     */
    data: {
        address_detail: {},
        // 所有已经领取的优惠券
        allCoupon: [],
        // 购买商品的列表，单个商品跳转往里追加，购物车跳转直接查购物车数据负值
        cart_list: [],
        list: [],

        //  0是购物车跳转过来全部购买、 1是单个商品跳转、2是购买多个指定商品
        type: '-1',
        uid: '',
        isNewUser: App.globalData.fulluserInfo?.is_new_user == 1 ? true : false,


        // 灰色遮罩层标识
        // 优惠券留客提示框的标识
        if_show_mask: false,
        if_show_mask2: false,
        if_show_end_paying_box: false,

        // 判断是否已经选择了收货地址
        // 邮寄地址列表弹出框标识
        // 邮寄地址列表
        // 所选地址的id
        if_address: false,
        if_show_box: false,
        address_list: [],
        chosen_id: 0,

        // 自提地址列表弹出框标识
        // 自提地址列表
        if_show_box_delivery: false,
        delivery_list: [],
        chosen_id_delivery: 0,

        // ？？？
        if_has_default: false,

        // 单个商品的 id、购买数量、规格
        good_id: '',
        number: 1,
        productID: -1,

        // 添加订单后本订单的编号
        orderIdCode: '',

        pay_waiting: false,
        options: {},

        visible: false,

        isVip: false,
        VipGrade: 0,

        // 缓存备注
        noteValue: '',
        // 统计字数
        strlength: 0,
        // 底部高度
        howtall: 20,

        positionStauts: 'relative',
        keyboardheight: 0,
        zindex: 5,


    },
    onUnload() {
        // 清除优惠券过期时间定时器
        if (timer) {
            clearInterval(timer)
            timer = null
        }
    },
    onHide() {

    },
    /**
     * 生命周期函数--监听页面加载
     */
    onLoad: async function (options) {
        await this.init_data(options)

        // await this.get_address_list()
        // await this.get_address()
        //this.get_delivery_list()
    },

    // 初始化数据，判断是哪一类的订单结算，获取对应商品数据展示
    async init_data(options) {
        console.log('options', options)
        let { goods_id, sku_id, goods_num } = options
        console.log(goods_id, sku_id, goods_num);

        // 会员套餐索引
        let index = 0
        switch (goods_num) {
            case "10":
                index = 2
                break;
            case "5":
                index = 1
                break;
            case "1":
                index = 0
                break;
            default:
                break;
        }

        this.setData({
            uid: App.globalData.uid,
            isVip: App.globalData.isVip,
            VipGrade: App.globalData.VipGrade,
            options,
            goods_id: goods_id,
            product_id: sku_id,
            goods_num: goods_num,
            cart_list: [combo_list[index]],
            submit_price: combo_list[index]["price"],
            chosen_index: index
        })
        console.log("num", this.data.goods_num);

    },

    // 点击购买回调
    async buying_vip() {
        console.log("this.aid", this.aid)

        // 未授权手机 拉起授权
        if (!App.globalData.mobile) {
            this.setData({
                visible: true
            })
            return
        }
        // 无地址 拉起地址弹框
        else if (!this.data.if_address) {
            util.showToast("您还没有添加收货地址")
            let timer = setTimeout(() => {
                this.choose_address()
                clearTimeout(timer)
            }, 1500);
            return
        }
        // 授权且带地址 执行支付流程
        else {
            this.paying()
        }
    },

    // 调起会员支付，新增会员商品订单。
    // 利用订单号获取微信支付信息，利用支付信息拉起微信支付
    paying() {
        let index = this.data.chosen_index
        let goods_num = 1
        switch (index) {
            case 0:
                goods_num = 1  // 银卡订单 1套
                break;
            case 1:
                goods_num = 5  // 金卡订单 5套
                break;
            case 2:
                goods_num = 10 // 钻石订单 10套
                break;
            default:
                break;
        }
        // 基本的请求参数信息
        let post_data = {
            uid: this.data.uid,
            aid: this.aid,
            type: 1,
            goods_id: this.data.goods_id,
            goods_sku_id: this.data.product_id, // 先写死的套餐id
            // goods_id: 258,
            // goods_sku_id: 24, // 先写死的套餐id
            order_type: "memberorder",
            goods_num,
            novip: true // 会员充值不能使用会员折扣 配合后端使用
        }
        // 开始支付流程
        request.post(api.orderaddv3, post_data).then(res => {
            this.oid = res[0]
            let post_data = {
                id: res[0]
            }

            request.post(api.orderpay3, post_data).then(res => {
                // 保存支付信息 提供"继续付款"调用
                this.pay_post_data = res
                this.wx_pay(res)
            })
        })
    },

    // 拉起微信支付
    wx_pay(res) {
        const that = this
        let post_data = res
        // console.log(post_data);
        wx.navigateToMiniProgram({
            appId: 'wxef277996acc166c3', // 目标小程序的appid
            extraData: post_data,        // 需要传递给目标小程序的数据，可选
            success(res) {
                // 打开成功的回调
            },
            fail(err) {
                // 打开失败的回调
            }
        });

    },

    // 返回上一页
    go_back() {
        wx.navigateBack({
            delta: 1
        });
    },

    // 记录备注
    inputHandler(e) {
        let str = e.detail.value
        let strlength = str.length
        // console.log(str, strlength);
        this.setData({
            noteValue: str,
            strlength
        })
    },

    taller() {
        if (this.data.pay_waiting) {
            wx.showModal({
                title: '温馨提示',
                content: '您已提交订单，备注需要联系客服添加哦',
                showCancel: false,
                success(res) {
                    if (res.confirm) {
                        console.log('用户点击确定')
                    } else if (res.cancel) {
                        console.log('用户点击取消')
                    }
                }
            })
            return
        }
    },
    // 自定义弹出层取消按钮回调
    cancelMethod() {
        this.setData({
            visible: false
        })
    },

    // 自定义弹出层点击空白处显示隐藏回调
    onVisibleChange(e) {
        this.setData({
            visible: e.detail.visible,
        });
    },

    // 手机授权按钮的回调
    async getrealtimePhoneNumber(e) {
        // console.log(e.detail.code)  // 拒绝：undefined 同意：code（和login的code不一样）
        // console.log(e.detail.errMsg) // 回调信息（成功失败都会返回）拒绝：fail user deny 同意：ok
        // console.log(e.detail.errno)  // 错误码（失败时返回）一般情况：undefined  使用次数上限：e.detail.errno===1400001

        // 先隐藏弹出层
        this.setData({
            visible: false
        })

        // console.log('e', e);
        // 用户同意且未达使用次数上限
        if (e.detail.errno == undefined && e.detail.code) {
            console.log('e.detail.code', e.detail.code);
            // 成功手机号授权会返回 true
            let phoneflag = await App.setPhone(e.detail.code)
            console.log('phoneflag', phoneflag);
            // 成功后请求用户完整信息
            if (phoneflag) {
                // 成功获取最新完整用户信息
                let fullRes = await App.getMyFullInfo()
                console.log('fullRes', fullRes);
                if (fullRes) {
                    this.init_data(this.data.options)
                    this.paying()
                    // console.log('是否有手机号？', this.data.mobile);
                } else {
                    util.showFail('信息获取超时请稍后重试')
                }
            }
        } else {
            util.showToast('已取消授权')
        }
    },

    // 请求自提地址列表
    get_delivery_list() {
        let params = {
        }
        request.post(api.deliverylist, params).then(res => {
            this.setData({
                delivery_list: res
            })
        })
    },

    // 设置顶部页面的地址信息，利用默认地址或者地址列表中第一个地址
    get_address() {
        let params = {
            uid: this.data.uid
        }
        request.post(api.addresslist, params).then(res => {
            // console.log('地址列表res:', res);
            // 没地址则直接退出
            if (res.length == 0) return
            this.setData({
                address_list: res
            })

            // 查找是否有默认地址
            for (let i of res) {
                if (i.is_default) {
                    this.aid = i.id
                    this.setData({
                        address_detail: i,
                        if_address: true,
                        aid: i.id,
                        chosen_id: i.id,
                    })

                    return
                }
            }
            // 如果地址列表里有地址但没有默认的
            if (this.data.if_address == false) {
                this.aid = res[0].id
                this.setData({
                    address_detail: res[0],
                    if_address: true,
                    aid: res[0].id,
                    chosen_id: res[0].id
                })
            }
        })

    },

    // 添加地址
    go_add_address() {
        let url = '/pages/address/add?type=' + this.data.type + '&good_id=' + this.data.good_id
        wx.navigateTo({
            url,
        })
    },

    // 编辑地址
    go_edit(e) {
        let url = '/pages/address/edit?id=' + e.currentTarget.dataset.id + '&uid=' + this.data.uid
        wx.navigateTo({
            url,
        })
    },

    // 用户更换邮寄地址
    change_address(e) {
        let chosen_id = e.currentTarget.dataset.id
        this.aid = chosen_id
        this.setData({
            chosen_id,
            chosen_id_delivery: 0,
            if_address: true
        })
        this.get_address_detail(chosen_id)
    },

    // 用户更换自提地址
    change_delivery(e) {
        let chosen_id_delivery = e.currentTarget.dataset.id
        this.setData({
            chosen_id_delivery,
            chosen_id: 0,
            if_address: true
        })
        this.get_delivery_detail(chosen_id_delivery)
    },


    // 根据所选自提点，更改页面顶部地址
    get_delivery_detail(id) {
        util.showLoading('正在更改地址')
        let params = {
            id
        }
        request.post(api.deliverydetail, params).then(res => {
            this.setData({
                address_detail: res
            })
            util.hideLoading(0)
        })
    },

    // 根据所选地址id，请求对应地址信息更改页面顶部地址
    get_address_detail(id) {
        util.showLoading('正在更改地址')
        let params = {
            id
        }
        request.post(api.addressdetail, params).then(res => {
            this.setData({
                address_detail: res,
                // 关闭弹出框
                if_show_box: false,
                if_show_mask: false
            })

            util.hideLoading()
        })
    },

    // 获取邮寄地址列表
    get_address_list() {
        let params = {
            uid: this.data.uid
        }
        request.post(api.addresslist, params).then(res => {
            this.setData({
                address_list: res
            })
        })
    },

    // 选择地址拉起地址列表框
    choose_address() {
        if (this.data.pay_waiting) {
            wx.showModal({
                title: '温馨提示',
                content: '需要修改收货地址请重新下单',
                showCancel: false,
                success(res) {
                    if (res.confirm) {
                        console.log('用户点击确定')
                    } else if (res.cancel) {
                        console.log('用户点击取消')
                    }
                }
            })
            return
        }
        this.setData({
            if_show_box: true,
            if_show_mask: true
        })
    },

    // 选择自提地址 拉起地址框
    choose_delivery() {
        if (this.data.pay_waiting) {
            wx.showModal({
                title: '温馨提示',
                content: '需要修改收货地址请重新下单',
                showCancel: false,
                success(res) {
                    if (res.confirm) {
                        console.log('用户点击确定')
                    } else if (res.cancel) {
                        console.log('用户点击取消')
                    }
                }
            })
            return
        }
        this.setData({
            if_show_box_delivery: true
        })
    },

    // 关闭邮寄地址框、遮罩层(点击空白区关闭所有弹出)
    clear_mask() {
        clearInterval(timer)
        this.setData({
            if_show_box: false,
            if_show_mask: false,
            isShowCoupon: false,
            if_show_end_paying_box: false
        })
    },

    // 关闭自提地址框、遮罩层
    clear_mask_delivery() {
        this.setData({
            if_show_mask: false,
            if_show_box_delivery: false
        })
    },

    // 继续支付
    continue_paying() {
        clearInterval(timer)
        this.setData({
            if_show_end_paying_box: false,
            if_show_mask: false,
        })
    },

    // 暂时放弃
    stop_paying() {
        clearInterval(timer)
        wx.navigateBack({
            delta: 1
        })
    },

    // 选择微信地址
    wx_choose_address() {
        const that = this
        // console.log('微信地址');
        util.showLoading('添加中')
        wx.chooseAddress({
            success: async (result) => {

                let params = {
                    uid: this.data.uid,
                    name: result.userName,
                    mobile: result.telNumber,

                    address: result.detailInfo,
                    is_default: 0
                }

                let pname = result.provinceName
                let cname = result.cityName
                let rname = result.countyName

                // 省份
                let provinceData = await that.getCityData()
                provinceData.forEach((item) => {
                    let oo = pname.indexOf(item.label)
                    if (oo != -1) {
                        params.province = item.value
                        params.province_name = item.label
                        return
                    }
                });

                // 城市
                let cityData = await that.getCityData(params.province)

                cityData.forEach((item) => {
                    let oo = cname.indexOf(item.label)
                    if (oo != -1) {
                        params.city = item.value
                        params.city_name = item.label
                        return
                    }
                });

                // 区县
                let regionData = await that.getCityData(params.city)

                regionData.forEach((item) => {
                    let oo = rname.indexOf(item.label)
                    if (oo != -1) {
                        params.region = item.value
                        params.area = item.value
                        params.region_name = item.label
                        return
                    }
                });
                console.log(params);

                request.post(api.addressadd, params).then(res => {
                    util.hideLoading()
                    that.get_address()
                    // this.onLoad(this.data.options)
                })
            },
            fail: (err) => {
                console.log('err', err);
                util.hideLoading()

            }
        })
    },

    // 获取省市区方法
    async getCityData(code = '') {
        let res = await request.postall(api.getcity, { code })
        if (res.code == 0) {
            let conData = res.data.con
            conData.forEach(item => {
                item.label = item.name
                item.value = item.code
            });
            return conData
        } else {
            util.showFail('地区信息获取失败')
        }
    },

    // 继续支付
    paying_waiting() {
        this.wx_pay(this.pay_post_data)
    },

    go_good_detail(e) {
        let id = e.currentTarget.dataset.id
        if (!id) {
            util.showToast('所选商品暂无记录')
            return
        }
        wx.navigateTo({
            url: '/pages/good/detail?id=' + id,
        })
    },

    keyboardheightchange(e) {
        let keyboardheight = e?.detail?.height || 0
        this.setData({
            if_show_mask: keyboardheight == 0 ? false : true,
            positionStauts: keyboardheight == 0 ? 'relative' : 'fixed',
            keyboardheight: keyboardheight,
            zindex: keyboardheight == 0 ? 5 : 10
        })
        // console.log(keyboardheight);
    },

    onShow: async function () {
        const that = this
        let returnOptions = wx.getEnterOptionsSync();

        console.log(returnOptions.scene, returnOptions.referrerInfo.appId, returnOptions.path);
        // 特殊说明：
        // 一般情况下wx.getEnterOptionsSync()中获取的extraData为收银台小程序返回的支付结果，
        // 但是当通过物理返回键或者通过半屏小程序右上角关闭退出（即未通过收银台小程序内按钮退出），
        // extraData内容会为空，调用方小程序会无法获得支付结果，该情况为微信小程序特性，小程序代码无法处理。
        // 如遇到该情况，通过判断场景值为1038且来源小程序为收银台小程序wxef277996acc166c3（上述代码加粗部分），
        // 即可认定为收银台返回，当前若extraData为空，则需要自行查询订单支付结果
        if (returnOptions.scene == '1038' && returnOptions.referrerInfo.appId == 'wxef277996acc166c3') {
            // 必须清除，否则会被自动保留下来，金顶的其他页面进入支付页也会跳提示。（未知bug）
            // 从收银台返回会重新获取，所以不影响判断支付结果
            returnOptions.scene = ""
            returnOptions.referrerInfo.appId = ""
            // 代表从收银台小程序返回
            let extraData = returnOptions.referrerInfo.extraData;
            console.log("extraData", extraData);
            if (!extraData) {
                // "当前通过物理按键返回，未接收到返参，建议自行查询交易结果";
                // util.showToast("物理按键返回，未获取支付结果")

                util.showLoading("支付结果检测中")
                setTimeout(async () => {
                    let oid = this.oid
                    let orderInfo = await request.post(api.orderdetail, { id: oid })
                    util.hideLoading()
                    console.log("orderInfo", orderInfo);
                    if (orderInfo.pay_status == 1) {
                        // 支付成功 
                        util.showToast("支付成功")

                        wx.showLoading({
                            title: '充值成功跳转中',
                        })
                        let goodid = that.data.goods_id
                        // console.log("goodid", goodid);
                        let trueGrade = -1
                        switch (goodid) {
                            case 110:
                                trueGrade = 1
                                break;
                            case 111:
                                trueGrade = 2
                                break;
                            case 112:
                                trueGrade = 3
                                break;
                            default:
                                trueGrade = 1
                                break;
                        }
                        // 原有会员，保留原级
                        let oldGrade = App.globalData.VipGrade
                        if (oldGrade >= trueGrade) {
                            trueGrade = oldGrade
                        }

                        // 记录原过期时间
                        let oldEndtime = App.globalData.fulluserInfo.end_time

                        let times = 0
                        let timerflag = setInterval(async () => {

                            // App.globalData.fulluserInfo = fulluserInfo
                            if (times >= 10) {
                                util.hideLoading()
                                clearInterval(timerflag)
                                util.showFail(
                                    "用户信息更新超时，联系客服解决"
                                )
                            }
                            let infoFlag = await App.getMyFullInfo()
                            if (infoFlag) {
                                let vipgrade = App.globalData.VipGrade
                                let newEndtime = App.globalData.fulluserInfo.end_time // 保证充值的时间更新

                                // console.log("vipgrade", vipgrade);
                                if (vipgrade == trueGrade && oldEndtime != newEndtime) {
                                    clearInterval(timerflag)
                                    util.hideLoading()

                                    wx.redirectTo({
                                        url: '/vip/vip',
                                        success: (result) => {

                                        },
                                        fail: () => { },
                                        complete: () => { }
                                    });
                                }
                            } else {
                                util.hideLoading()
                                clearInterval(timerflag)
                                util.showFail(
                                    "用户信息更新失败，请联系客服"
                                )
                            }
                            times++
                        }, 1000);
                    } else {
                        // 支付取消
                        util.showToast("支付已取消")
                        this.setData({ pay_waiting: true });
                    }
                }, 1000);
            } else {

                if (extraData.code == 'success') {

                    // "支付成功";
                    util.showToast("支付成功")
                    wx.showLoading({
                        title: '充值成功跳转中',
                    })
                    let goodid = that.data.goods_id
                    // console.log("goodid", goodid);
                    let trueGrade = -1
                    switch (goodid) {
                        case 110:
                            trueGrade = 1
                            break;
                        case 111:
                            trueGrade = 2
                            break;
                        case 112:
                            trueGrade = 3
                            break;
                        default:
                            trueGrade = 1
                            break;
                    }
                    // 原有会员，保留原级
                    let oldGrade = App.globalData.VipGrade
                    if (oldGrade >= trueGrade) {
                        trueGrade = oldGrade
                    }

                    // 记录原过期时间
                    let oldEndtime = App.globalData.fulluserInfo.end_time

                    let times = 0
                    let timerflag = setInterval(async () => {

                        // App.globalData.fulluserInfo = fulluserInfo
                        if (times >= 10) {
                            util.hideLoading()
                            clearInterval(timerflag)
                            util.showFail(
                                "用户信息更新超时，联系客服解决"
                            )
                        }
                        let infoFlag = await App.getMyFullInfo()
                        if (infoFlag) {
                            let vipgrade = App.globalData.VipGrade
                            let newEndtime = App.globalData.fulluserInfo.end_time // 保证充值的时间更新

                            // console.log("vipgrade", vipgrade);
                            if (vipgrade == trueGrade && oldEndtime != newEndtime) {
                                clearInterval(timerflag)
                                util.hideLoading()

                                wx.redirectTo({
                                    url: '/vip/vip',
                                    success: (result) => {

                                    },
                                    fail: () => { },
                                    complete: () => { }
                                });
                            }
                        } else {
                            util.hideLoading()
                            clearInterval(timerflag)
                            util.showFail(
                                "用户信息更新失败，请联系客服"
                            )
                        }
                        times++
                    }, 1000);

                } else if (extraData.code == 'cancel') {

                    // "支付已取消";
                    util.showToast("支付已取消")
                    this.setData({ pay_waiting: true });

                } else {
                    // "支付失败：" + extraData.errmsg;
                    util.showToast("支付失败")
                }
            }
        }

        if (App.globalData.isVip != this.data.isVip) {
            this.init_data(this.data.options)
        }
        // this.get_address_list()
        await this.get_address()
    },

})